home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / StaticTView.C < prev    next >
C/C++ Source or Header  |  1992-08-24  |  20KB  |  838 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "StaticTView.h"
  6.  
  7. #include "Class.h"
  8. #include "String.h"
  9. #include "View.h"
  10. #include "Window.h"
  11. #include "PrintManager.h"
  12. #include "TextFormatter.h"
  13. #include "TextPainter.h"
  14. #include "TextStyles.h"
  15. #include "CheapText.h"
  16. #include "Invariant.h"
  17. #include "Document.h"
  18. #include "Math.h"
  19.  
  20. Rectangle gFitRect(cFit, cFit);
  21.  
  22. void StaticTextView::SwapRange(int &a, int &b)
  23. {
  24.     int tmp;
  25.     tmp= a; a= b; b= tmp;
  26. }
  27.  
  28. inline LineMark *MarkAt(ObjArray *oa, int at)
  29. {
  30.     return (LineMark*)(*oa)[at]; 
  31. }
  32.  
  33. void StaticTextView::Dump()
  34. {
  35.     for(int i= 0; i < nLines; i++) {
  36.     if(MarkAtLine(i) == 0)
  37.         fprintf(stderr, "Mark is NULL at %d\n!!!", i);
  38.     else 
  39.         fprintf(stderr, "%d. %d-%d\n", i, StartLine(i), EndLine(i));
  40.     }
  41.     fprintf(stderr, "nLines= %d\n", nLines);
  42. }
  43.  
  44. void StaticTextView::ClassInvariant()
  45. {
  46.     if (GetAssertLevel() > 5)
  47.     return;
  48.     if(nLines > lines->Size()) 
  49.     fprintf(stderr, "!!!StaticTextView Invariant: nLines > lines->Size()!!!\n");
  50.     for(int i= 1; i < nLines; i++) {
  51.     if(MarkAtLine(i) == 0) {
  52.         fprintf(stderr, "!!!StaticTextView Invariant: Mark is NULL at %d!!!\n", i);
  53.         Dump();
  54.     }
  55.     else if(StartLine(i) == EndLine(i)) { 
  56.         fprintf(stderr, "!!!StaticTextView Invariant: Empty line at %d!!!\n", i);
  57.         Dump();
  58.     }
  59.     else if(StartLine(i) != EndLine(i-1)) {
  60.         fprintf(stderr, "!!!StaticTextView Invariant: Discontinous lines %d %d %d!!!\n", i, StartLine(i),
  61.                                    EndLine(i-1));
  62.         Dump();
  63.     }
  64.     }
  65. }
  66.     
  67. static TextPainter *sPainter;
  68. static TextFormatter *sFormatter;
  69. static CheapText *sText;
  70.  
  71. ONEXIT(StaticTextView)
  72. {
  73.     SafeDelete(sPainter);
  74.     SafeDelete(sFormatter);
  75.     SafeDelete(sText);
  76. }
  77.  
  78. //---- static methods ---------------------------------------------------------
  79.  
  80. Metric StaticTextView::MeasureText(char *text, Font* fd, int minwidth, int l)
  81. { 
  82.     if (l <= 1) {
  83.     if (minwidth > 0 || text == 0)
  84.         return Metric(minwidth, fd->Spacing(), fd->Ascender());
  85.     return Metric(fd->Width((byte*)text), fd->Spacing(), fd->Ascender());
  86.     }
  87.     return Metric(minwidth, l*fd->Spacing(), fd->Ascender());
  88. }
  89.  
  90. void StaticTextView::DrawBoxedText(Rectangle r, char *txt, 
  91.                         Font *fp, Ink *ink, bool wrap)
  92. {
  93.     Point p(r.origin);
  94.     p.y+= fp->Ascender();
  95.  
  96.     if (!wrap) {
  97.     Metric m(fp->Width((byte*)txt), fp->Spacing(), fp->Ascender());
  98.     if (m.extent.x > r.extent.x || m.extent.y > r.extent.y) {
  99.         GrState gs;
  100.         GrClipFurther(r);
  101.         GrShowString(fp, ink, p, (byte*)txt);
  102.     } else
  103.         GrShowString(fp, ink, p, (byte*)txt);
  104.     return;
  105.     }
  106.     
  107.     if (sPainter == 0) {
  108.     sPainter= new TextPainter;
  109.     sFormatter= new FoldingFormatter;
  110.     sText= new CheapText;
  111.     }
  112.     sText->ReplaceWithStr((byte*)txt);
  113.     sText->SetFont(fp);
  114.  
  115.     int nLines= sFormatter->Format(sText, sPainter, r.Width(), 0, sText->Size());
  116.     ObjArray *lines= sFormatter->GetLines();
  117.     
  118.     GrState gs;
  119.     GrClipFurther(r);
  120.     Ink *oldtextink= GrGetTextInk();
  121.     GrSetTextInk(ink);
  122.     register int i, lh, bh;
  123.     Rectangle lr(p.x, p.y-fp->Ascender(), p.x, MarkAt(lines, 0)->Height());
  124.     bh= MarkAt(lines, 0)->Base();
  125.     for (i= 0; i < nLines; i++) {
  126.     int start= MarkAt(lines, i)->Pos(), end= MarkAt(lines, i)->End();
  127.     sPainter->Draw(sText, p, start, end, lr, r, FALSE); 
  128.     p.y+= (lh= MarkAt(lines, i)->Height())-bh;
  129.     if (i < nLines-1)
  130.         p.y+= (bh= MarkAt(lines, i+1)->Base());
  131.     lr.origin.y+= lh; 
  132.     }        
  133.     GrSetTextInk(oldtextink);
  134. }
  135.  
  136. //----- StaticTextView Methods -------------------------------------------------
  137.  
  138. NewMetaImpl(StaticTextView, View, (TP(text), TP(pager), TP(painter), TP(formatter),
  139.     TE(align), TB(wrap), TB(drawViewBorder), TB(horExtend), T(border),
  140.     T(nLines), TP(lines), TP(marks)));
  141.  
  142. StaticTextView::StaticTextView(
  143.     EvtHandler *eh, Rectangle r, Text *t, 
  144.     bool w, TextViewFlags f, Point b, 
  145.     TViewAlign ta, int id
  146. ) : View(eh, r, id) 
  147. {
  148.     Init(r, t, w, f, b, ta);
  149. }   
  150.  
  151. void StaticTextView::Init(
  152.     Rectangle r, Text* t, bool w, TextViewFlags f, Point b, TViewAlign ta
  153. )
  154. {
  155.     lines= new ObjArray(32);
  156.     marks= new MarkList(FALSE, lines);
  157.     contentRect= r;
  158.     text= t;
  159.     align= ta;
  160.     wrap= w;
  161.     drawViewBorder= FALSE;
  162.     border= b;
  163.  
  164.     cline= 0;
  165.     cYPosition= 0;
  166.     
  167.     horExtend= (contentRect.extent.x == cFit);
  168.     if (horExtend)
  169.     wrap= FALSE;
  170.     
  171.     if (!wrap)
  172.     formatter= new SimpleFormatter();
  173.     else
  174.     formatter= new FoldingFormatter();
  175.     painter= new TextPainter();
  176.     
  177.     RepairAll();
  178.     
  179.     if ((f & eTextViewInvis) == eTextViewInvis)
  180.     SetFlag(eTextViewInvis);
  181.     if ((f & eTextViewReadOnly) == eTextViewReadOnly)
  182.     SetFlag(eTextViewReadOnly);
  183.     if ((f & eTextWantFindFocus) == eTextWantFindFocus)
  184.     SetFlag(eTextWantFindFocus);
  185.     if ((f & eTextViewNoBatch) == eTextViewNoBatch)
  186.     SetFlag(eTextViewNoBatch);
  187.     if ((f & eTextViewNoClip) == eTextViewNoClip)
  188.     SetFlag(eTextViewNoClip);
  189. }
  190.  
  191. StaticTextView::~StaticTextView()
  192. {
  193.     if (lines)
  194.     lines->FreeAll();
  195.     SafeDelete(marks);
  196.     SafeDelete(formatter);
  197.     SafeDelete(painter);
  198.     SafeDelete(pager);
  199. }
  200.  
  201. void StaticTextView::Draw(Rectangle r)
  202. {
  203.     register int i, lh, bh;
  204.     int startAt= PointToLine(r.origin-GetInnerOrigin());
  205.     Ink *oldtextink= 0; 
  206.  
  207.     if (startAt >= nLines)
  208.     return;
  209.       
  210.     GrState gs;
  211.     if (!TestFlag(eTextViewNoClip))
  212.     GrClipFurther(Rectangle(GetInnerOrigin(), GetInnerExtent()));
  213.     Point p= LineToPoint(startAt,TRUE) + GetInnerOrigin();
  214.     Rectangle lineRect(
  215.     GetInnerOrigin().x, p.y-BaseHeight(startAt),
  216.     GetInnerExtent().x, LineHeight(startAt)
  217.     );
  218.  
  219.     if (!Enabled()) {
  220.     oldtextink= GrGetTextInk();
  221.     GrSetTextInk(ePatGrey50);
  222.     }
  223.  
  224.     bh= BaseHeight(startAt);
  225.     for (i= startAt; ; i++) {
  226.     if (! r.Intersects(lineRect))
  227.         break;
  228.     DrawLine(p, i, lineRect, r);
  229.     if (i >= nLines-1)
  230.         break;
  231.     p.y+= (lh= LineHeight(i))-bh;
  232.     p.y+= (bh= BaseHeight(i+1));
  233.     lineRect.origin.y+= lh; 
  234.     }        
  235.     if (drawViewBorder) {
  236.     GrSetPenInk(ePatGrey50);
  237.     GrSetPenSize(2);
  238.     GrStrokeRect (Rectangle (contentRect.origin,contentRect.extent));
  239.     }
  240.     if (! Enabled())
  241.     GrSetTextInk(oldtextink);
  242. }
  243.  
  244. void StaticTextView::Repair(int from, int to, bool redraw)
  245. {
  246.     int prevBreak, nextBreak;
  247.     int prevLine, nextLine;
  248.     
  249.     ResetFlag(eTextViewModified);
  250.     prevBreak= text->FindLastBreak(from);
  251.     if(prevBreak < 0)
  252.     prevLine= -1;
  253.     else
  254.     prevLine= CharToLine(prevBreak);
  255.     prevLine= Math::Min(nLines-1, prevLine+1);
  256.     nextBreak= text->FindNextBreak(to);
  257.     if(nextBreak >= text->Size())
  258.     nextLine= nLines-1;
  259.     else
  260.     nextLine= CharToLine(nextBreak);
  261.     
  262.     int n= formatter->Format(
  263.     text, painter, GetInnerExtent().x,
  264.     prevBreak+1, nextBreak+1
  265.     );
  266.     ObjArray *newLines= formatter->GetLines();
  267.     
  268.     int extentDiff= UpdateView(prevLine, nextLine, n, newLines, redraw);
  269.     UpdateComposition(prevLine, nextLine, n, newLines);
  270.     UpdateExtent(extentDiff);
  271.     if (pager)
  272.     pager->Repaginate(prevLine);
  273. //    ClassInvariant();
  274. }
  275.  
  276. Rectangle StaticTextView::NextPageBreak(int pn, Rectangle r)
  277. {
  278.     if (pager == 0)
  279.     pager= new TextPager();
  280.     return pager->NextPageBreak(pn, r, this);
  281. }
  282.  
  283. int StaticTextView::UpdateView(
  284.     int prev, int next, int n, ObjArray *newLines, bool redraw
  285. ) 
  286. {
  287.     int i, j;
  288.     int invalid, valid;
  289.     
  290.     int newHeight= 0, oldHeight= 0;
  291.     for(i= 0; i < n; i++)
  292.     newHeight+= MarkAt(newLines, i)->Height();
  293.     for(i= prev; i <= next; i++)
  294.     oldHeight+= MarkAtLine(i)->Height();
  295.     
  296.     if(redraw) {
  297.     invalid= prev;
  298.     valid= cMaxInt;
  299.     } else {    
  300.     invalid= prev;
  301.     for(i= prev; i < prev+n && i <= next; i++) {
  302.         if(MarkAt(newLines, i-prev)->IsDifferent(MarkAtLine(i))) 
  303.         break;
  304.     }
  305.     invalid= i;
  306.         
  307.     valid= nLines;
  308.     if (oldHeight == newHeight) {
  309.         for(j= prev+n-1; j > invalid && j < nLines; j--) {
  310.         if(!MarkAt(newLines, j-prev)->IsDifferent(MarkAtLine(j))) 
  311.             valid= j;
  312.         else
  313.             break;
  314.         }               
  315.         if(valid == nLines)
  316.         valid= Math::Min(nLines, prev+n);
  317.         InvalidateRange(invalid, Math::Max(0, valid-1)); //
  318.     }
  319.     else 
  320.            InvalidateRange(invalid, Math::Max(0, valid-1));
  321.     }
  322.     InvalidateRange(invalid, Math::Max(0, valid-1));
  323.     //---- update line cache
  324.     LineToPoint(Math::Max(0, invalid-1));
  325.     return newHeight-oldHeight;
  326. }
  327.     
  328. void StaticTextView::UpdateComposition(
  329.     int prev, int next, int n, ObjArray *newLines
  330. ) 
  331. {
  332.     int diff= n-(next-prev+1);
  333.     register int i;
  334.     
  335.     if(lines->Size() < nLines+diff)
  336.     lines->Expand((nLines+diff)*2);
  337.     if(diff > 0) {
  338.     for(i= nLines-1; i > next; i--)
  339.         lines->AtPut(i+diff, lines->At(i));
  340.     for(i= next+1; i <= next+diff; i++)
  341.         lines->AtPut(i, 0);
  342.     } else if (diff < 0) {
  343.     for(i= next+diff+1; i <= next; i++) {
  344.         LineMark *lm= MarkAtLine(i);
  345.         SafeDelete(lm);
  346.     }
  347.     for(i= next+1; i < nLines; i++)
  348.         lines->AtPut(i+diff, MarkAtLine(i));
  349.     for(i= nLines+diff; i < nLines; i++)
  350.         lines->AtPut(i, 0);    
  351.     }
  352.     
  353.     for(i= prev; i < prev+n; i++) {
  354.     LineMark *m1= MarkAtLine(i);
  355.     if(m1 == 0)
  356.         m1= new LineMark();
  357.     m1->Copy(MarkAt(newLines, i-prev));
  358.     lines->AtPut(i, m1);
  359.     }    
  360.     nLines+= diff;
  361. }
  362.  
  363. void StaticTextView::DrawLine(Point p, int i, Rectangle lr, Rectangle cr)
  364. {
  365.     int start= StartLine(i), end= EndLine(i);
  366.     painter->Draw(text, p, start, end, lr, cr, TestFlag(eTextViewInvis)); 
  367. }
  368.  
  369. void StaticTextView::SetFont(Font* fd)
  370. {
  371.     text->SetFont(fd);
  372.     RepairAll();
  373. }
  374.  
  375. void StaticTextView::SetFormatter(TextFormatter *f)
  376. {
  377.     SafeDelete(formatter);
  378.     formatter= f;
  379. }
  380.  
  381. void StaticTextView::SetPainter(TextPainter *p)
  382. {
  383.     SafeDelete(painter);
  384.     painter= p;
  385. }
  386.  
  387. void StaticTextView::SetPager(TextPager *p)
  388. {
  389.     SafeDelete(pager);
  390.     pager= p;
  391. }
  392.  
  393. void StaticTextView::SetAlign(TViewAlign m)
  394. {
  395.     align= m;
  396.     RepairAll();
  397. }
  398.  
  399. void StaticTextView::ShowInvisibles(bool m)
  400. {
  401.     if (TestFlag(eTextViewInvis) != m) {
  402.         SetFlag(eTextViewInvis, m);
  403.         ForceRedraw();
  404.     }
  405. }
  406.  
  407. bool StaticTextView::GetShowInvis()
  408. { 
  409.     return TestFlag(eTextViewInvis); 
  410. }
  411.  
  412. void StaticTextView::SetWordWrap(bool m)
  413. { 
  414.     if (wrap == m)
  415.     return;
  416.     wrap= m;
  417.     SafeDelete(formatter);
  418.     if (wrap)
  419.     formatter= new FoldingFormatter(); 
  420.     else
  421.     formatter= new SimpleFormatter(); 
  422.     RepairAll();
  423. }
  424.  
  425. bool StaticTextView::GetWordWrap()
  426. { 
  427.     return wrap; 
  428. }
  429.  
  430. void StaticTextView::SetNoBatch(bool m)
  431. {
  432.     SetFlag(eTextViewNoBatch, m);
  433. }
  434.  
  435. bool StaticTextView::GetNoBatch()
  436. { 
  437.     return TestFlag(eTextViewNoBatch); 
  438. }
  439.  
  440. Text *StaticTextView::SetText(Text *t, bool scroll)
  441. {
  442.     Text *old= text;
  443.     text= t;   
  444.     SetFlag(eTextViewModified);
  445.     RepairAll();  
  446.     if (scroll == cRevealTop)
  447.     Scroll(cPartScrollAbs, gPoint0, FALSE);
  448.     Send(GetId(), cPartReplacedText, 0);
  449.     return old;
  450. }
  451.  
  452. void StaticTextView::SetString(byte *str, int len)
  453. {
  454.     text->ReplaceWithStr(str, len);
  455.     RepairAll();
  456.     Send(GetId(), cPartReplacedText, 0);  
  457. }
  458.  
  459. void StaticTextView::RepairAll()
  460. {
  461.     // flush line cache
  462.     LineToPoint(0);
  463.     nLines= 1;
  464.     contentRect.extent.y= 2*border.y;
  465.     LineMark *m= MarkAtLine(0);
  466.     if (m == 0) {
  467.     m= new LineMark();
  468.     lines->AtPut(0, m);
  469.     }
  470.     m->ChangeMark(0, text->Size(), LineDesc(), eStateChanged);
  471.     Repair(0, text->Size(), TRUE);
  472.     ForceRedraw();
  473. }
  474.  
  475. void StaticTextView::SetExtent(Point p)
  476. {
  477.     if (p != contentRect.extent) {
  478.     View::SetExtent(p);
  479.     horExtend= (p.x == cFit);
  480.     if (horExtend)
  481.         wrap= FALSE;
  482.     SafeDelete(formatter);
  483.     if (!wrap)
  484.         formatter= new SimpleFormatter();
  485.     else
  486.         formatter= new FoldingFormatter();
  487.     RepairAll();
  488.     }
  489. }
  490.  
  491. Metric StaticTextView::GetMinSize()
  492. {
  493.     if (TestFlag(eTextViewModified))
  494.     RepairAll();
  495.     return Metric(GetExtent(), LineToPoint(0, TRUE).y+border.y);
  496. }
  497.  
  498. void StaticTextView::UpdateExtent(int dy)
  499. {
  500.     Point newExtent(contentRect.extent);
  501.     Point newOrigin(contentRect.origin);
  502.     register int i, s, e;
  503.  
  504.     newExtent.y+= dy;
  505.  
  506.     if (horExtend) {
  507.     newExtent.x= 0;
  508.     for (i= 0; i < nLines; i++) {
  509.         s= StartLine(i);
  510.         e= EndLine(i);
  511.         newExtent.x= Math::Max(newExtent.x, painter->LineWidth(text, s, e));
  512.     }
  513.     newExtent.x += 2*border.x;
  514.     if (align != eTViewLeft) 
  515.         newOrigin.x= AlignView(newExtent.x);
  516.     }
  517.  
  518.     InvalidateDiff(newOrigin, newExtent);
  519.     
  520.     if (newOrigin != contentRect.origin) 
  521.     View::SetOrigin(newOrigin);
  522.     if (newExtent != contentRect.extent) 
  523.     View::SetExtent(newExtent);
  524. }
  525.  
  526. void StaticTextView::InvalidateDiff(Point newOrigin, Point newExtent)
  527. {
  528.     if (newExtent != contentRect.extent) {
  529.     Rectangle r[4];
  530.     Rectangle oldRect(contentRect);
  531.     oldRect.Expand(Point(4, 0));
  532.     Rectangle newRect(newOrigin, newExtent);
  533.     newRect.Expand(Point(4, 0));
  534.     int n= Difference(r, newRect, oldRect);
  535.     for (int i= 0; i < n; i++)
  536.         InvalidateRect(r[i]);
  537.     }   
  538. }
  539.  
  540. Point StaticTextView::LineToPoint(int n, bool basePoint, bool relative)
  541. {
  542.     register i, y= cYPosition;
  543.     
  544. //  int _cYPos, _cline;
  545. //  _cYPos= cYPosition; _cline= cline; 
  546.     n= Math::Range(0, nLines, n);
  547.     if (cline < n) 
  548.     for(i= cline; i < n; i++)
  549.         y+= LineHeight(i);
  550.     else if (cline > n) 
  551.     for(i= cline-1; i >= n; i--)
  552.         y-= LineHeight(i);
  553.     cYPosition= y;
  554.     cline= n;
  555.     
  556. //    int yy= 0;
  557. //    for (int ii= 0; ii < n; ii++)
  558. //        yy+= LineHeight(ii);
  559. //    if (cYPosition != yy)
  560. //        fprintf(stderr, "LineToPoint: cYPosition %d!= %d, p=%d l=%d\n", 
  561. //            cline, n, _cYPos, _cline); 
  562.  
  563.     if (basePoint)
  564.     y+= BaseHeight(n);
  565.     if (relative)
  566.     return Point(0, y);
  567.     return GetInnerOrigin() + Point(0, y);
  568. }
  569.  
  570. int StaticTextView::PointToLine(Point p) // p is in coordinates relative to contentRect
  571. {
  572.     int i, py= Math::Range(0, contentRect.Height(), p.y), lh;
  573.  
  574. //    int _py, _cYPos, _cline;
  575. //    _py= py; _cYPos= cYPosition; _cline= cline; 
  576.     if(py >= cYPosition) {
  577.     for(i= cline; i < nLines; i++) {
  578.         lh= LineHeight(i);
  579.         if (cYPosition + lh > py)
  580.         break;
  581.         cYPosition+= lh;
  582.     }
  583.     cline= i;
  584.     } else {
  585.     for(i= cline-1; i >= 0 ; i--) {
  586.         cYPosition-= LineHeight(i);
  587.         if (cYPosition <= py) 
  588.         break;
  589.     }
  590.     cline= Math::Max(i, 0);
  591.     }
  592.     
  593. //    register int ll, y2= 0;
  594. //    for (ll= 0; ll < nLines; ll++) {
  595. //        lh= LineHeight(ll);
  596. //        if (y2 + lh > py)
  597. //            break;
  598. //        y2+= lh;
  599. //    }
  600. //    if (ll != cline) 
  601. //        fprintf(stderr, "PointToLine: cline %d!= %d, p=%d y=%d l=%d\n", 
  602. //            cline, ll, _py, _cYPos, _cline); 
  603.     return cline; 
  604. }
  605.  
  606. //---- map a point in view coordinates to line and character number
  607.  
  608. void StaticTextView::PointToPoint(
  609.     Point p, Point *viewPos, int *lineNo, int *charNo, bool relative
  610. )
  611. {
  612.     int start, end, cx= 0, l; 
  613.     if (!relative)
  614.         p-= GetInnerOrigin();
  615.     l= PointToLine(p);
  616.     if (l >= nLines) {
  617.     l= nLines-1;
  618.     p.x= contentRect.extent.x;    // set to end of line
  619.     }
  620.     if (l < 0) {
  621.     l= 0;
  622.     p.x= contentRect.origin.x;            // set to start of line
  623.     }
  624.     start= StartLine(l);
  625.     end= EndLine(l);
  626.  
  627.     *charNo= painter->Map(text, start, end, end, p.x, GetInnerExtent().x, &cx);
  628.     *lineNo= l;
  629.     *viewPos= Point(cx, LineToPoint(l).y);
  630.     if (!relative)
  631.         (*viewPos) += GetInnerOrigin();
  632. }
  633.  
  634. int StaticTextView::CharToLine(int ch)
  635. {
  636.     register int base, pos, last, s;
  637.     
  638.     base= pos= 0;
  639.     last= nLines-1;
  640.     
  641.     while (last >= base) { // binary search
  642.     pos= (base+last) / 2;
  643.     if (EndLine(pos) > ch && (s= StartLine(pos)) <= ch)
  644.         break;
  645.     if (StartLine(pos) > ch)
  646.         last= pos-1;
  647.     else
  648.         base= pos+1;
  649.     }
  650.     return Math::Max(0, Math::Min(pos, nLines-1));
  651. }
  652.  
  653. int StaticTextView::CharToPoint(int charNo, int *lineNo, Point *viewPos, bool relative)
  654. {
  655.     int line, ch, start, end, x;
  656.     Point p;
  657.  
  658.     ch= Math::Range(0, text->Size(), charNo);
  659.     line= CharToLine(ch);
  660.     p.y= LineToPoint(line).y;
  661.     if (line >= nLines && line > 0) { // beyound end of text
  662.     p.y-= LineHeight(line);
  663.     line= Math::Max(0,nLines-1);
  664.     }
  665.     start= StartLine(line);
  666.     end= EndLine(line);
  667.  
  668.     ch= painter->Map(text, start, end, charNo, cMaxInt, GetInnerExtent().x, &x); 
  669.     *viewPos= p;
  670.     viewPos->x+= x;
  671.     if (!relative)
  672.     *viewPos += GetInnerOrigin();
  673.     *lineNo= line;
  674.     return ch;
  675. }
  676.  
  677. int StaticTextView::LineHeight(int l)
  678. {
  679.     l= Math::Range(0, nLines-1, l);
  680.     return MarkAtLine(l)->Height();
  681. }
  682.     
  683. int StaticTextView::BaseHeight(int l)
  684. {
  685.     l= Math::Range(0, nLines-1, l);
  686.     return MarkAtLine(l)->Base();
  687. }
  688.  
  689. void StaticTextView::InvalidateRange(int from, int to)
  690. {
  691.     if (from > to)  // normalize range
  692.     SwapRange(from, to);
  693.     from= Math::Range(0, nLines-1, from);
  694.     to=   Math::Range(0, nLines-1, to);
  695.     Point p= LineToPoint(from),
  696.       t= Point(contentRect.extent.x, LineToPoint(to).y+LineHeight(to));
  697.     Rectangle r= NormRect(p, t);
  698.  
  699.     r += GetInnerOrigin();
  700.     if (from == 0)  { // consider border
  701.     r.origin.y -= border.y;
  702.     r.extent.y += border.y;
  703.     }
  704.     if (to == nLines-1 || to == 0) 
  705.     r.extent.y += border.y;
  706.     InvalidateRect(r.Expand(Point(Math::Max(4,border.x),0)));
  707. }
  708.  
  709. int StaticTextView::AlignView(int newX)
  710. {
  711.     int x;
  712.     // adjust origin
  713.     switch (align) {
  714.     case eTViewCenter:
  715.     x= contentRect.origin.x + 
  716.               (contentRect.extent.x-newX)/2;
  717.     break;
  718.     case eTViewRight:
  719.     x= contentRect.origin.x + 
  720.               (contentRect.extent.x-newX);
  721.     break;
  722.     }
  723.     return x;
  724. }
  725.  
  726. void StaticTextView::InvalidateRange(int from, Point fp, int to, Point tp)
  727. {
  728.     Rectangle r;
  729.  
  730.     from= Math::Range(0, nLines-1, from);
  731.     to=   Math::Range(0, nLines-1, to);
  732.  
  733.     if ((from == to && fp.x > tp.x) || from > to) { // normalize range
  734.     SwapRange(from, to);
  735.     Swap(fp, tp);   
  736.     }
  737.  
  738.     if (from == to) { // optimize invalidate on one line
  739.     r= Rectangle(LineToPoint(from)+Point (fp.x,0),
  740.                     Point(tp.x-fp.x, LineHeight(from)));
  741.     if (from == 0)  { // consider border
  742.         r.origin.y -= border.y;
  743.         r.extent.y += border.y;
  744.     }
  745.     if (to == nLines-1 || to == 0) 
  746.         r.extent.y += border.y;
  747.     r.origin+= GetInnerOrigin();
  748.     InvalidateRect(r.Expand(Point(Math::Max(4,border.x),0)));
  749.     return;
  750.     }
  751.     InvalidateRange(from, to);
  752. }
  753.  
  754. char *StaticTextView::AsString()
  755. {
  756.     return text->AsString();
  757. }
  758.  
  759. OStream& StaticTextView::PrintOn (OStream&s)
  760. {
  761.     View::PrintOn(s);
  762.     return s << text SP << wrap SP << align SP 
  763.          << horExtend SP << border SP << contentRect.extent;
  764. }
  765.  
  766. IStream& StaticTextView::ReadFrom(IStream &s)
  767. {
  768.     Text *txt;
  769.     bool wrap, hExtend;
  770.     Point extent, itsBorder;
  771.     TViewAlign align;
  772.     Rectangle r;
  773.  
  774.     SafeDelete(text);
  775.  
  776.     View::ReadFrom(s);
  777.     s >> txt >> Bool(wrap) >> Enum(align) 
  778.       >> Bool(hExtend) >> itsBorder >> extent;
  779.     r= Rectangle(extent);
  780.     if (hExtend)
  781.     r.extent.x= cFit;
  782.  
  783.     Init(r, txt, wrap, eTextViewNone, itsBorder, align);
  784.     return s;
  785. }
  786.  
  787. void StaticTextView::AddMark(Mark *m)
  788. {
  789.     text->AddMark(m);
  790. }
  791.  
  792. Mark *StaticTextView::RemoveMark(Mark *m)
  793. {
  794.     return text->RemoveMark(m);
  795. }
  796.  
  797. Iterator *StaticTextView::GetMarkIter()
  798. {
  799.     return text->GetMarkIter();
  800. }
  801.  
  802. MarkList *StaticTextView::GetMarkList()
  803. {
  804.     return text->GetMarkList();
  805. }
  806.  
  807. void StaticTextView::InspectorId(char *buf, int sz)
  808. {
  809.     if (text)
  810.     text->InspectorId(buf, sz);
  811.     else
  812.     View::InspectorId(buf, sz);
  813. }
  814.  
  815. void StaticTextView::CollectParts(Collection* col)
  816. {
  817.     View::CollectParts(col);
  818.     col->Add(text);
  819. }
  820.  
  821. void StaticTextView::PrintAdorn(Rectangle, int gPageNo)
  822. {
  823.     Rectangle r(gPrintManager->GetViewRect());
  824.     Point o;
  825.     byte *p;
  826.     Font *f= new_Font(eFontTimes, 12, eFaceBold);
  827.     r.origin.y-= 10;
  828.  
  829.     p= (byte*) GetDocument()->GetBaseName();
  830.     o= f->AdjustString(p, r.NW(), eAdjVBottom, eAdjHLeft);
  831.     GrShowString(f, gInkBlack, o, p);
  832.  
  833.     p= (byte*) form("Page: %d", gPageNo);
  834.     o= f->AdjustString(p, r.NE(), eAdjVBottom, eAdjHRight);
  835.     GrShowString(f, gInkBlack, o, p);
  836. }
  837.     
  838.